import request from "../../../utils/request";

Page({
  /**
   * 页面的初始数据
   */
  data: {
    status: 'yituikuan', // 订单状态（从列表页接收）
    orderNo: '', // 订单编号（核心查询参数）
    // 订单详情数据（根据后端实际返回结构）
    orderDetail: {
      // 基础订单信息
      orderNo: '', // 订单编号
      orderAmount: 0, // 订单金额
      orderStatus: 0, // 订单状态
      expectedServiceTime: '', // 期望服务时间
      remark: '', // 备注
      createTime: '', // 下单时间
      // 关联对象
      nursingItem: {}, // 护理项目信息
      elderly: {}, // 老人信息
      orderUser: {}, // 下单用户信息
      bed: {}, // 床位信息
      // 退款相关字段
      refundNo: '', // 退款编号
      refundReason: '', // 退款原因
      applicationTime: '', // 申请时间
      refundAmount: 0, // 退款金额
      refundTime: '', // 退款时间
      refundStatus: 0, // 退款状态
      refundChannel: '', // 退款渠道
      refundMethod: '', // 退款方式
      failureStatusCode: '', // 失败状态码
      failureReason: '', // 失败原因
      // 关闭相关字段
      closeTime: '', // 关闭时间
      closeReason: '', // 关闭原因
      // 执行相关字段
      executor: {}, // 执行人信息
      executeTime: '', // 执行时间
      updateTime: '', // 更新时间
      executeRecord: '', // 执行记录
      executeImages: [] // 执行图片
    },
    isLoading: true, // 加载状态
    loadError: false, // 加载失败状态
    remainingSeconds: 0, // 剩余支付秒数（倒计时核心变量）
    countdownText: '00分00秒', // 格式化后的倒计时文本
    countdownTimer: null // 定时器实例
  },

  /**
   * 生命周期函数--监听页面加载
   */
  onLoad(options) {
    // 1. 接收从订单列表传递的参数
    const status = options.status || 'unknown';
    const orderNo = options.id || ''; // 列表页传递的id即订单编号


    // 订单编号缺失处理
    if (!orderNo) {
      wx.showToast({ title: '订单编号缺失', icon: 'none' });
      wx.navigateBack();
      return;
    }

    // 2. 存储基础参数
    this.setData({
      status: status,
      orderNo: orderNo
    });

    // 3. 调用接口查询订单详情
    this.getOrderDetail(orderNo);
  },

  /**
   * 调用后端接口查询订单详情
   * @param {string} orderNo - 订单编号
   */
  getOrderDetail(orderNo) {
    this.setData({ isLoading: true, loadError: false });

    request({
      url: `/orderManagement/orderManagement/getOrderByOrderNO`,
      method: 'GET',
      data: { orderNo: orderNo }
    }).then(resp => {
      this.setData({ isLoading: false });

      if (resp.data.code === 200) {
        const backendData = resp.data.data;
        
        // 调试信息：打印后端返回的原始数据
        console.log('后端返回的订单详情原始数据：', backendData);
        
        // 根据后端返回的状态值重新设置状态
        let newStatus = this.data.status; // 默认使用传入的状态
        switch (backendData.orderStatus) {
          case 0:
            newStatus = 'daizhifu';
            break;
          case 1:
            newStatus = 'daifuwu';
            break;
          case 2:
            newStatus = 'yizhixing';
            break;
          case 3:
            newStatus = 'yiwancheng';
            break;
          case 4:
            newStatus = 'yituikuan';
            break;
          case 5:
            newStatus = 'yiguanbi';
            break;
          default:
            newStatus = 'unknown';
        }
        
        
        // 适配后端数据为页面渲染格式
        const formattedDetail = this.formatOrderDetail(backendData);
        this.setData({ 
          orderDetail: formattedDetail,
          status: newStatus // 更新状态值
        });

        // 查询退款记录（如果有退款相关状态）
        if (newStatus === 'tuikuanzhong' || newStatus === 'tuikuanshibai' || newStatus === 'yituikuan') {
          this.getRefundRecord(backendData.orderNo); // 使用订单编号
        }

        // 查询任务安排（如果有执行相关状态）
        if (newStatus === 'yizhixing' || newStatus === 'yiwancheng') {
          this.getTaskArrangement(backendData.orderNo); // 使用订单编号
        }

        // 待支付状态：启动倒计时
        if (newStatus === 'daizhifu') {
          let totalSeconds = 0;
          // 方式1：优先使用后端返回的剩余支付秒数（精准）
          if (backendData.remainingPaySeconds) {
            totalSeconds = backendData.remainingPaySeconds;
          } else {
            // 方式2：前端计算（订单创建时间+15分钟超时 - 当前时间）
            const createTime = new Date(backendData.createTime).getTime();
            const timeoutMinutes = 15; // 默认15分钟超时
            const expireTime = createTime + timeoutMinutes * 60 * 1000;
            totalSeconds = Math.ceil((expireTime - new Date().getTime()) / 1000);
            totalSeconds = Math.max(totalSeconds, 0); // 避免负数
          }
          this.startCountdown(totalSeconds);
        }
      } else {
        wx.showToast({ title: '获取订单详情失败', icon: 'none' });
        this.setData({ loadError: true });
      }
    }).catch(err => {
      console.error('查询订单详情失败：', err);
      this.setData({ isLoading: false, loadError: true });
      wx.showToast({ title: '网络异常，获取失败', icon: 'none' });
    });
  },

  /**
   * 适配后端详情数据为页面渲染格式
   * @param {object} backendData - 后端返回的原始详情数据
   * @returns {object} 格式化后的数据
   */
  formatOrderDetail(backendData) {
    // 日期格式化工具
    const formatDate = (dateStr) => {
      if (!dateStr) return '';
      return dateStr.replace(' ', '  '); // 空格替换为双空格，匹配页面格式
    };

    return {
      // 基础订单信息
      orderNo: backendData.orderNo || '',
      orderAmount: backendData.orderAmount || 0,
      orderStatus: backendData.orderStatus || 0,
      expectedServiceTime: formatDate(backendData.expectedServiceTime) || '',
      remark: backendData.remark || '无',
      createTime: formatDate(backendData.createTime) || '',
      
      // 关联对象直接赋值
      nursingItem: backendData.nursingItem || {},
      elderly: backendData.elderly || {},
      orderUser: backendData.orderUser || {},
      bed: backendData.bed || {},

      // 退款相关信息
      refundNo: backendData.refundNo || '',
      refundReason: backendData.refundReason || '',
      applicationTime: formatDate(backendData.applicationTime) || '',
      refundAmount: backendData.refundAmount || 0,
      refundTime: formatDate(backendData.refundTime) || '',
      refundStatus: backendData.refundStatus || 0,
      refundChannel: backendData.refundChannel || '',
      refundMethod: backendData.refundMethod || '',
      failureStatusCode: backendData.failureStatusCode || '',
      failureReason: backendData.failureReason || '',

      // 关闭相关信息
      closeTime: formatDate(backendData.updateTime) || '',
      closeReason: backendData.closeReason || backendData.cancelReason || '超时未支付',

      // 执行相关信息
      executor: backendData.executor || {},
      executeTime: formatDate(backendData.updateTime) || '',
      updateTime: formatDate(backendData.updateTime) || '', // 添加updateTime字段
      executeRecord: backendData.executeRecord || '无执行记录',
      executeImages: backendData.executeImages || []
    };
  },

  /**
   * 查询退款记录
   * @param {string} orderNo - 订单编号
   */
  getRefundRecord(orderNo) {
    request({
      url: `/refund/refund/getInfoByOrderNo?orderNo=`+orderNo,
      method: 'GET',
    }).then(resp => {
      console.log('退款记录查询结果：', resp.data);
      if (resp.data.code === 200 && resp.data.data) {
        const refundData = resp.data.data;
        // 更新订单详情中的退款信息
        this.setData({
          'orderDetail.refundNo': refundData.refundNo || '',
          'orderDetail.refundReason': refundData.refundReason || '',
          'orderDetail.applicationTime': this.formatDate(refundData.applicationTime) || '',
          'orderDetail.refundAmount': refundData.refundAmount || 0,
          'orderDetail.refundTime': this.formatDate(refundData.refundTime) || '',
          'orderDetail.refundStatus': refundData.refundStatus || 0,
          'orderDetail.refundChannel': refundData.refundChannel || '',
          'orderDetail.refundMethod': refundData.refundMethod || '',
          'orderDetail.failureStatusCode': refundData.failureStatusCode || '',
          'orderDetail.failureReason': refundData.failureReason || ''
        });
      }
    }).catch(err => {
      console.error('查询退款记录失败：', err);
    });
  },

  /**
   * 查询任务安排
   * @param {string} orderNo - 订单编号
   */
  getTaskArrangement(orderNo) {
    request({
      url: `/serve/arrangement/relatedOrder/${orderNo}`,
      method: 'GET'
    }).then(resp => {
      console.log('任务安排查询结果：', resp.data);
      if (resp.data.code === 200 && resp.data.data) {
        const taskData = resp.data.data;
        
        // 处理执行图片（可能是单个字符串或数组）
        let executeImages = [];
        if (taskData.executionImage) {
          // 如果executionImage是字符串，按逗号分割成数组
          executeImages = typeof taskData.executionImage === 'string' 
            ? taskData.executionImage.split(',').filter(img => img.trim()) 
            : taskData.executionImage;
        }
        
        // 更新订单详情中的执行信息
        this.setData({
          'orderDetail.executor': {
            userName: taskData.executorName || '未知执行人'
          },
          'orderDetail.executeTime': this.formatDate(taskData.executionTime) || '',
          'orderDetail.updateTime': this.formatDate(taskData.executionTime) || this.formatDate(taskData.createTime) || '',
          'orderDetail.executeRecord': taskData.executionRecord || taskData.orderRemark || '无执行记录',
          'orderDetail.executeImages': executeImages
        });
      }
    }).catch(err => {
      console.error('查询任务安排失败：', err);
    });
  },

  /**
   * 日期格式化工具
   * @param {string} dateStr - 日期字符串
   * @returns {string} 格式化后的日期字符串
   */
  formatDate(dateStr) {
    if (!dateStr) return '';
    return dateStr.replace(' ', '  '); // 空格替换为双空格，匹配页面格式
  },

  /**
   * 格式化秒数为"分:秒"文本
   * @param {number} seconds - 剩余秒数
   * @returns {string} 格式化后的文本（如“14分53秒”）
   */
  formatCountdown(seconds) {
    if (seconds <= 0) return '00分00秒';
    const minute = Math.floor(seconds / 60);
    const second = seconds % 60;
    return `${String(minute).padStart(2, '0')}分${String(second).padStart(2, '0')}秒`;
  },

  /**
   * 启动倒计时
   * @param {number} totalSeconds - 总超时秒数
   */
  startCountdown(totalSeconds) {
    this.clearCountdown(); // 清除已有定时器

    // 初始化倒计时数据
    this.setData({
      remainingSeconds: totalSeconds,
      countdownText: this.formatCountdown(totalSeconds)
    });

    // 创建定时器，每秒更新
    const timer = setInterval(() => {
      this.setData({
        remainingSeconds: this.data.remainingSeconds - 1
      }, () => {
        const { remainingSeconds } = this.data;
        // 更新格式化文本
        this.setData({ countdownText: this.formatCountdown(remainingSeconds) });

        // 倒计时结束：处理超时逻辑
        if (remainingSeconds <= 0) {
          this.clearCountdown();
          wx.showToast({ title: '订单已超时，已自动关闭', icon: 'none' });
          // 2秒后返回订单列表
          setTimeout(() => {
            wx.navigateBack();
          }, 2000);
        }
      });
    }, 1000);

    this.setData({ countdownTimer: timer });
  },

  /**
   * 暂停倒计时
   */
  pauseCountdown() {
    const { countdownTimer } = this.data;
    if (countdownTimer) clearInterval(countdownTimer);
  },

  /**
   * 清除倒计时
   */
  clearCountdown() {
    const { countdownTimer } = this.data;
    if (countdownTimer) {
      clearInterval(countdownTimer);
      this.setData({ countdownTimer: null });
    }
  },

  /**
   * 重新加载订单详情
   */
  handleReload() {
    this.getOrderDetail(this.data.orderNo);
  },

  /**
   * 返回上一级页面
   */
  backArrow() {
    wx.navigateBack();
  },

  /**
   * 去支付页面
   */
  goPay() {
    wx.navigateTo({
      url: `/pages/my/affordorder/affordorder?orderNo=${this.data.orderNo}`
    });
  },

  /**
   * 去填写取消订单原因
   */
  toCancelReason() {
    wx.navigateTo({
      url: `/pages/service/cancelReason/cancelReason?orderNo=${this.data.orderNo}`
    });
  },

  /**
   * 生命周期函数--监听页面显示
   */
  onShow() {
    // 待支付状态且有剩余时间：恢复倒计时
    if (this.data.status === 'daizhifu' && this.data.remainingSeconds > 0) {
      this.startCountdown(this.data.remainingSeconds);
    }
  },

  /**
   * 生命周期函数--监听页面隐藏
   */
  onHide() {
    // 暂停倒计时
    this.pauseCountdown();
  },

  /**
   * 生命周期函数--监听页面卸载
   */
  onUnload() {
    // 彻底清除定时器（避免内存泄漏）
    this.clearCountdown();
  },

  /**
   * 页面相关事件处理函数--监听用户下拉动作
   */
  onPullDownRefresh() {
    wx.stopPullDownRefresh();
  },

  /**
   * 页面上拉触底事件的处理函数
   */
  onReachBottom() {},

  /**
   * 用户点击右上角分享
   */
  onShareAppMessage() {}
});